package com.vitaf.cash.app.ui.dialog

import android.annotation.SuppressLint
import android.app.Activity
import android.app.Dialog
import android.content.Context
import android.view.KeyEvent
import android.view.View
import android.view.WindowManager
import android.widget.LinearLayout
import com.vitaf.cash.app.R
import com.vitaf.cash.app.databinding.VitafDlogLoadingBinding
import com.vitaf.cash.app.utils.VitafImgLoader
import java.lang.ref.WeakReference

class VitafLoadingDlogV2 private constructor(context: Context, private val config: LoadingConfig = LoadingConfig()) : Dialog(context, R.style.DialogTheme) {
    private val binding: VitafDlogLoadingBinding = VitafDlogLoadingBinding.inflate(layoutInflater)
    private val contextRef = WeakReference(context)

    init {
        initializeDialog()
        setupContentView()
        configureWindow()
    }

    /**
     * 初始化对话框基本设置
     */
    private fun initializeDialog() {
        setContentView(binding.root)
        setCancelable(config.isCancelable)
        setCanceledOnTouchOutside(config.isTouchOutsideCancelable)
    }

    /**
     * 设置内容视图
     */
    private fun setupContentView() {
        // 加载GIF图片
        VitafImgLoader.instance?.loadImageGifRes(context, binding.gifLoading, R.mipmap.gombe_credit_image_loading_gif)

        // 设置加载文字
        if (config.message.isNotEmpty()) {
            binding.textLoading.visibility = View.VISIBLE
            binding.textLoading.text = config.message
        } else {
            binding.textLoading.visibility = View.GONE
        }
    }

    /**
     * 配置窗口属性
     */
    private fun configureWindow() {
        window?.apply {
            // 设置背景透明
            setBackgroundDrawableResource(R.color.transparent)

            // 设置窗口属性
            val attributes = attributes?.apply {
                flags = WindowManager.LayoutParams.FLAG_DIM_BEHIND
                dimAmount = 0.5f // 背景透明度
            }
            attributes?.let { setAttributes(it) }

            // 设置布局参数
            setLayout(LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT)
        }
    }

    @SuppressLint("GestureBackNavigation")
    override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
        // 处理返回键
        if (keyCode == KeyEvent.KEYCODE_BACK) {
            if (!config.isCancelable) {
                return true // 拦截返回键
            }
        }
        return super.onKeyDown(keyCode, event)
    }

    override fun show() {
        val context = contextRef.get()
        // 检查上下文有效性
        if (context is Activity && context.isFinishing) {
            return
        }

        try {
            if (!isShowing) {
                super.show()
            }
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }

    override fun dismiss() {
        try {
            if (isShowing) {
                super.dismiss()
            }
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }

    /**
     * 更新加载消息
     * @param message 新的加载消息
     */
    fun updateMessage(message: String) {
        if (message.isNotEmpty()) {
            binding.textLoading.visibility = View.VISIBLE
            binding.textLoading.text = message
        } else {
            binding.textLoading.visibility = View.GONE
        }
    }

    companion object {

        /**
         * 创建加载对话框
         * @param context 上下文
         * @param config 配置参数
         * @return VitafLoadingDlogV2 实例
         */
        fun create(context: Context, config: LoadingConfig = LoadingConfig()): VitafLoadingDlogV2 {
            return VitafLoadingDlogV2(context, config)
        }

        /**
         * 显示加载对话框（简化版）
         * @param context 上下文
         * @param message 加载消息
         */
        fun show(context: Context, message: String = "") {
            val config = LoadingConfig(message = message)
            show(context, config)
        }

        /**
         * 显示加载对话框（完整配置版）
         * @param context 上下文
         * @param config 配置参数
         */
        fun show(context: Context, config: LoadingConfig) {
            // 先隐藏已存在的对话框
            safeDismiss()

            val dialog = create(context, config)
            DialogManager.register(dialog)
            dialog.show()
        }

        /**
         * 隐藏加载对话框 - 使用 reified 版本
         */
        fun dismiss() {
            DialogManager.unregister<VitafLoadingDlog>()?.dismiss()
        }

        /**
         * 安全地隐藏对话框 - 使用 reified 版本
         */
        fun safeDismiss() {
            DialogManager.safeDismiss<VitafLoadingDlog>()
        }

        /**
         * 检查是否正在显示 - 使用 reified 版本
         */
        fun isShowing(): Boolean {
            return DialogManager.isShowing<VitafLoadingDlog>()
        }

        /**
         * 获取当前对话框实例 - 使用 reified 版本
         */
        fun getCurrentDialog(): VitafLoadingDlog? {
            return DialogManager.getDialog<VitafLoadingDlog>()
        }
    }
}

/**
 * 加载对话框配置类
 * 使用数据类提供默认参数，便于扩展
 */
data class LoadingConfig(
    val message: String = "",
    val isCancelable: Boolean = true,
    val isTouchOutsideCancelable: Boolean = false
)

/**
 * 对话框管理器
 * 用于统一管理所有对话框实例，防止内存泄漏和重复显示
 */
object DialogManager {
    private val dialogs = mutableMapOf<String, WeakReference<Dialog>>()

    /**
     * 注册对话框
     */
    fun register(dialog: Dialog) {
        dialogs[dialog.javaClass.name] = WeakReference(dialog)
    }

    // region reified 版本（使用更方便）
    /**
     * 注销并获取对话框 - reified 版本
     */
    @Suppress("UNCHECKED_CAST")
    inline fun <reified T : Dialog> unregister(): T? {
        return unregister(T::class.java)
    }

    /**
     * 安全地隐藏对话框 - reified 版本
     */
    inline fun <reified T : Dialog> safeDismiss() {
        safeDismiss(T::class.java)
    }

    /**
     * 检查指定类型的对话框是否正在显示 - reified 版本
     */
    inline fun <reified T : Dialog> isShowing(): Boolean {
        return isShowing(T::class.java)
    }

    /**
     * 获取指定类型的对话框（不移除） - reified 版本
     */
    inline fun <reified T : Dialog> getDialog(): T? {
        return getDialog(T::class.java)
    }
    // endregion

    // region Class 参数版本（更灵活）
    /**
     * 注销并获取对话框 - Class 参数版本
     */
    @Suppress("UNCHECKED_CAST")
    fun <T : Dialog> unregister(clazz: Class<T>): T? {
        val key = clazz.name
        return dialogs.remove(key)?.get() as? T
    }

    /**
     * 安全地隐藏对话框 - Class 参数版本
     */
    fun <T : Dialog> safeDismiss(clazz: Class<T>) {
        val dialog = unregister(clazz)
        dialog?.let {
            try {
                if (it.isShowing) {
                    it.dismiss()
                }
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
    }

    /**
     * 检查指定类型的对话框是否正在显示 - Class 参数版本
     */
    fun <T : Dialog> isShowing(clazz: Class<T>): Boolean {
        val key = clazz.name
        return dialogs[key]?.get()?.isShowing == true
    }

    /**
     * 获取指定类型的对话框（不移除） - Class 参数版本
     */
    fun <T : Dialog> getDialog(clazz: Class<T>): T? {
        val key = clazz.name
        return dialogs[key]?.get() as? T
    }

    /**
     * 清除所有对话框引用
     */
    fun clearAll() {
        // 先安全地关闭所有对话框
        dialogs.values.forEach { dialogRef ->
            dialogRef.get()?.let { dialog ->
                try {
                    if (dialog.isShowing) {
                        dialog.dismiss()
                    }
                } catch (e: Exception) {
                    e.printStackTrace()
                }
            }
        }
        dialogs.clear()
    }

    /**
     * 获取所有正在显示的对话框数量
     */
    fun getShowingDialogCount(): Int {
        return dialogs.values.count { it.get()?.isShowing == true }
    }

    /**
     * 获取注册的对话框总数
     */
    fun getRegisteredDialogCount(): Int {
        return dialogs.size
    }
}